Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems - resenha crítica

Imagine que você está prestes a construir seu primeiro agente inteligente de verdade. Não um chatbot solto, mas um sistema capaz de tomar decisões, executar tarefas, corrigir erros, recuperar informações e aprender com o tempo. O livro de Gullí propõe que esse processo não é uma sequência de improvisações, mas uma jornada estruturada em padrões. Eles funcionam como blocos de construção que você combina conforme o agente se torna mais sofisticado.

A narrativa começa no ponto zero: nenhuma linha de código escrita, nenhuma arquitetura definida. Apenas a intenção de criar um agente útil, confiável e evolutivo.

Começando pelo núcleo: o agente precisa de intenção, estrutura e um primeiro ciclo

Todo agente nasce de um objetivo. A primeira decisão é simples: o que ele precisa fazer? Não importa se o propósito é responder perguntas, planejar viagens ou coordenar tarefas corporativas. A lógica inicial é idêntica. É nesse instante que o livro introduz o padrão mais básico: Planning.

O agente não pode agir sem traduzir o objetivo em etapas. Você o treina para decompor o problema: entender o pedido, dividir a execução em partes, ordenar essas partes. O planejamento ainda é raso, porque o agente não tem memória, ferramentas nem capacidade de se autoavaliar. Mas ele já possui um esqueleto funcional. A estrutura básica está criada: um loop inicial de intenção → plano → execução.

O segundo passo é fazer esse plano se desdobrar em ações. Surge então o padrão Prompt Chaining. O agente passa a operar em microetapas encadeadas: interpretar o contexto, verificar requisitos, executar uma ação mínima, avaliar o resultado. Cada encadeamento soma complexidade. Você logo percebe que fazer tudo linearmente é insuficiente. Algumas tarefas demandam caminhos alternativos, forks, diferentes níveis de detalhe. Entra em cena o padrão Routing. Ele permite que o agente direcione partes do processo para diferentes fluxos internos, como se fossem mini-módulos dentro dele.

Nesse estágio inicial, você tem um ciclo básico, mas rígido. Falta robustez. É hora de evoluir.

O agente aprende a agir no mundo: ferramentas, APIs e a capacidade de operar fora de si

Planejar e encadear prompts não basta para resolver problemas reais. Um agente útil precisa tocar o mundo: consultar bancos de dados, chamar APIs, manipular arquivos, extrair informações externas. Gullí chama isso de Tool Use.

Você ensina o agente que, diante de uma tarefa que requer dados externos, ele deve avaliar se é preciso chamar uma ferramenta. Depois, deve preparar a chamada, interpretar o retorno e reinserir esse resultado no fluxo. A partir desse ponto, o agente deixa de ser apenas um gerador de texto. Ele se aproxima de um sistema operacional de alto nível.

Com ferramentas disponíveis, surge a necessidade de lidar com tarefas que podem ser executadas simultaneamente. O padrão Parallelization entra em jogo. Seu agente agora consegue conduzir duas ou mais ações ao mesmo tempo. Enquanto busca um conjunto de dados, pode também preparar uma análise preliminar. Enquanto organiza as instruções, pode chamar uma API externa que demora alguns segundos.

A combinação de planejamento + ferramentas + paralelização cria o primeiro salto real de capacidade. Mas ainda falta o principal: o agente continua sem senso crítico. Ele executa sem avaliar.

O agente passa a avaliar a si mesmo: reflexão, verificação e correção

Na terceira etapa, introduzimos o padrão Reflection. Ele permite que o agente examine a própria saída. Você ensina o sistema a perguntar: “Isso responde ao objetivo? Há erros? Falta algo? A inferência está lógica?”

O livro enfatiza que a reflexão é um dos maiores diferenciais entre um sistema estático e um agente propriamente dito. Depois de cada bloco de execução, o agente inicia uma revisão. Caso detecte problemas, replaneja, corrige ou refaz. Esse refinamento cria um ciclo contínuo de autoaperfeiçoamento dentro da mesma tarefa.

Mas reflexão não basta se o agente não souber lidar com falhas estruturais. Por isso, Gullí insere o padrão Exception Handling and Recovery. O agente aprende a detectar situações que fogem do esperado — erros de rede, falha de API, informação incompleta, inconsistência de contexto — e, em vez de travar, ele executa procedimentos de recuperação. Repetir a chamada, buscar alternativas, redirecionar o fluxo para uma ferramenta mais confiável, ou pedir intervenção humana.

Agora o agente começa a parecer robusto: ele planeja, age, avalia e se recupera.

O agente precisa de memória: contexto curto, contexto longo e aprendizado incremental

Até aqui, o agente ainda vive no presente. Cada tarefa é isolada. Se você quer que ele se torne realmente útil, ele precisa lembrar. Gullí introduz então o padrão Memory Management.

Primeiro, a memória curta. O agente precisa manter no contexto informações essenciais para executar etapas subsequentes sem se perder. Depois, a memória de longo prazo, armazenada fora do modelo, geralmente num banco vetorial. Ela guarda histórico, decisões passadas, preferências do usuário, detalhes sobre o ambiente.

Para que a memória seja funcional, é necessário um mecanismo de triagem: o agente precisa decidir o que vale conservar e o que deve ser descartado para não sobrecarregar o sistema. Por isso, entra o padrão Model Context Protocol (MCP). Ele define critérios para filtrar informações relevantes, reduzir ruído e preservar apenas o material necessário para a continuidade da tarefa.

Com memória ativa, chega o próximo salto: Learning and Adaptation. O agente passa a identificar padrões no próprio desempenho. Ele entende o que costuma funcionar, quais ferramentas são mais confiáveis, onde geralmente erra, e ajusta seu comportamento baseado nesses aprendizados. Essa adaptação pode ser explícita (regras) ou implícita (feedback iterativo). Não é aprendizado de máquina em larga escala, mas sim uma evolução baseada em uso.

Nesse ponto, seu agente se aproxima do que Gullí considera um sistema realmente inteligente: capaz de lembrar, raciocinar e evoluir com o tempo.

O agente não trabalha sozinho: colaboração e comunicação entre agentes

Quando um único agente se torna muito complexo, o sistema começa a perder clareza. Gullí propõe dividir funções entre agentes especializados e fazê-los cooperar. Surge então o padrão Multi-Agent Collaboration.

Em vez de um único agente resolver tudo, você cria agentes especialistas:

• um planejador;
• um executor de ferramentas;
• um analista de dados;
• um verificador de qualidade;
• um supervisor geral.

Cada agente opera com seus próprios padrões, memória e ferramentas. O ganho é enorme: clareza, modularidade, desempenho e escalabilidade.

Para isso funcionar, surge o padrão complementar Inter-Agent Communication. Agentes precisam se comunicar por mensagens padronizadas, enviar resultados parciais, delegar subtarefas, sincronizar contexto. A comunicação não é caótica: ela segue protocolos e formatos claros, o que evita loops infinitos ou decisões contraditórias.

A colaboração multiagente cria novas capacidades: um agente pode avaliar o trabalho do outro, corrigir divergências, validar cálculos, trocar contexto quando necessário.
O sistema deixa de ser um “agente” e se torna um ecossistema de agentes.

O agente aprende a consultar conhecimento externo: RAG como um braço cognitivo

Mesmo que o agente tenha memória e ferramentas, ele ainda precisa buscar informações atualizadas, documentos externos, dados corporativos. Gullí introduz então o padrão Knowledge Retrieval (RAG).

O agente aprende a:

• formular a necessidade de informação;
• buscar documentos relevantes numa base vetorial;
• escolher os trechos úteis;
• integrar o conteúdo recuperado na resposta final.

Com isso, o agente passa a operar com conhecimento estruturado. Ele consulta políticas internas, relatórios, base jurídica, documentação técnica. Não adivinha: recupera. Esse padrão reduz alucinação, aumenta precisão e modulariza conhecimento.

A integração entre RAG, ferramentas e multiagentes cria um salto qualitativo. O agente não só opera. Ele consulta, verifica, valida e contextualiza.

Surge a preocupação com recursos: custo, eficiência e priorização

Quanto mais poderoso fica o agente, maior o consumo de recursos. Gullí então introduz Resource-Aware Optimization. O agente passa a considerar custo de inferência, tempo de execução, tamanho do contexto e quantidade de chamadas a APIs. Ele ajusta sua estratégia com base nessas variáveis.

Ele também precisa decidir o que fazer primeiro. Entra o padrão Prioritization. O agente avalia urgência, impacto e dependências. Ele reorganiza o plano conforme o valor esperado de cada ação. Em sistemas multiagentes, essa priorização evita conflitos e retrabalho.

Se a tarefa exige coleta de informações, validação, análise e síntese, o agente decide qual etapa merece mais esforço computacional e qual pode ser simplificada. O resultado é um sistema mais barato, mais rápido e mais confiável.

A importância do humano: supervisão, limites e tomada de decisão

Quando o agente ganha autonomia, surge a necessidade de supervisão. O livro apresenta o padrão Human-in-the-Loop.

O humano serve como auditor, validador, interventor e coordenador. O agente consulta o humano em situações como:

• risco alto;
• decisões ambíguas;
• inconsistências graves;
• respostas fora da política da empresa.

Essa supervisão não é constante, mas pontual. Ela funciona como um mecanismo de segurança.

E falando em segurança, surge o padrão essencial: Guardrails/Safety Patterns. Ele define limites, políticas, filtros e verificações que protegem contra erros, vieses, violações de privacidade ou ações indevidas. Essa camada garante que, mesmo sendo autônomo, o agente opere dentro das regras.

Avaliação contínua: medir qualidade, corrigir rumos e entender comportamento

A etapa final da construção é o padrão Evaluation and Monitoring. Seu agente agora:

• registra logs;
• mede métricas internas;
• avalia qualidade de inferência;
• monitoriza falhas e exceções;
• rastreia custos;
• aprende com o feedback.

Com monitoramento contínuo, você detecta gargalos, identifica padrões de erro e ajusta o design. O agente se torna auditável. Ele deixa rastros operacionais que permitem entender como chegou a cada decisão.

Esse padrão completa o ciclo: agora o agente não apenas executa, mas se sequencia, se corrige, se otimiza e se explica.

A última camada: exploração e descoberta

Com tudo isso pronto, resta um último padrão: Exploration and Discovery. Este é o padrão que transforma um agente de execução em um agente proativo.

• Ele testa abordagens alternativas.
• Ele tenta novos caminhos.
• Ele descobre padrões inesperados.
• Ele propõe soluções não triviais.

A exploração permite que o agente ultrapasse o comportamento puramente reativo. Ele não responde apenas ao que você pede. Ele identifica oportunidades, gaps, riscos ou novos caminhos que você talvez não tenha percebido.

Notas Finais

A narrativa proposta por Gullí mostra que um agente inteligente não nasce completo. Ele se constrói em camadas. Começa com planejamento básico e encadeamento de ações. Ganha ferramentas, paralelização e capacidade de agir. Desenvolve reflexão, recuperação e segurança. Aprende a lembrar e adaptar. Cresce para colaborar com outros agentes. Passa a consultar conhecimento, otimizar recursos e pedir ajuda humana quando necessário. Depois aprende a avaliar e monitorar. Por fim, desenvolve capacidade de explorar caminhos novos.

Esse processo transforma um simples uso de LLM em um sistema verdadeiramente agentic: resiliente, organizado, confiável e útil.